Object

var mrDeng = {
    name : "MrDeng",
    age : 40,
    sex : "male",
    health : 100,
    smoke : function(){
        var str = 'I am smoking ! cool!!!'
        this.health --;
        console.log(str + this.health);
    },
    drink : function(){
        var str = 'I am drink'
        this.health ++;
        console.log(str + this.health);
    }
}

• 增：mrDeng.wife = "xiaoliu";
• 删：delete mrDeng.sex;
• 改：mrDeng.sex = "female";
• 查：console.log(mrDeng.sex);

创建对象方法

1. var obj = {} plainObject 对象字面量/对象直接量
2. 构造函数

• 系统自带的构造函数 new Object()

var obj = new Object();
obj.name = 'abc';
obj.sex = 'female';
obj.say = function(){}

• 自定义

function Car(){
    this.name = "BMW";
    this.height = 1400;
    this.lang = 4900;
    this.health = 100;
    this.run = function(){
        this.health --;
    }
}
var car1 = new Car();
var car2 = new Car();
car1.name = "Infiniti";

对象拷贝

浅层克隆

只拷贝，两个对象指向同一个地址，改变非原始值另一个对象也会跟着改变

var obj = {
    name : 'abc',
    age : 123,
    sex : 'female'
}
var obj1 = {}

// 封装 clone 方法
function clone(origin, target){
    var target = target || {};
    for(var prop in origin){
        target[prop] = origin[prop];
    }
    return target;
}
clone(obj, obj1);

深度克隆

两个对象指向两个地址

var obj = {
    name : "abc",
    age : 123,
    card : ['vise', 'mastar'],
    wife : {
        name : "bcd",
        son : "aaa"  
    }
}
var obj1 = {}

// 封装 deepClone 方法
function deepClone(origin, target){
    var target = target || {};
    toStr = Object.prototype.toString,
    arrStr = "[object Array]";
    for (var prop in origin) {
        if (origin.hasOwnProperty(prop)) {  // 判断自身属性是否存在
            if (typeof(origin[prop]) !== 'null' && typeof(origin[prop]) === 'object') {
                target[prop] = toStr.call(origin[prop]) == arrStr ? [] : {};
                deepClone(origin[prop],target[prop]);
            } else {
                target[prop] = origin[prop];
            }
        }
    }
}
deepClone(obj, obj1);

对象枚举

for in

var arr = [1,2,3,4,5,6,7,8,9];
// 遍历 枚举
for (var i = 0; i < arr.length; i ++) {
    console.log(arr[i]);
}

in, hasOwnProperty

var obj = {
    name : "wang",
    age : 18,
    sex : "male",
    height : 180,
    width : 45,
    __proto__ : {
        lastName : "deng"
    }
}
for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) {  // .hasOwnProperty() 排除原型
        console.log(obj[prop]);
        // obj.prop == obj['prop'] != obj[prop]
    }
}

in (不分青红皂白,会访问到父级) hasOwnProperty (只访问自己)

instanceof

function Person(){}
var person  = new Person();
var obj = {}
person instanceof Person  //--> true  看 person 对象的原型链上有没有 Person 的原型
person instanceof Object  //--> true
person instanceof Array  //--> false
obj instanceof Person  //--> false

toString.call

Object.prototype.toString.call([]);  //--> [Object Array]
Object.prototype.toString.call(123);  //--> [Object Number]
Object.prototype.toString.call({});  //--> [Object Object]
Object.prototype.toString.call(null);  //--> [Object Null]

区别数组和对象的三种方法 .canstrutor .instanceof .toString.call()

对象中的键值遍历规律

• 先按数字排序，后按书写顺序排序（方便运算，方便定位内存地址，提高运行效率）

const obj = {
    p2: 'aaa',
    1: 'aaa',
    2: 'aaa',
    p1: 'aaa'
}
for (var key in obj) {
    console.log(key);  //--> 1 2 p2 p1
}